// import 'dart:async';
// import 'dart:math';
// import 'package:flutter/material.dart';
// import 'package:heartrate_monitoring/models/devicesModels.dart';
// import 'package:flutter_blue_plus/flutter_blue_plus.dart';
// import 'package:heartrate_monitoring/services/logger.dart';
// import 'package:permission_handler/permission_handler.dart';
// class BlManager with ChangeNotifier{
  
// // 定义全局变量保存订阅对象和特征值引用
//   Map<String, StreamSubscription<List<int>>> _subscriptions = {};
//   Map<String, BluetoothCharacteristic> _characteristics = {};
//   // 当前连接的设备
//   BluetoothDevice? _connectedDevice;

//   // 当前连接的服务和特征
//   BluetoothService? _connectedService;
//   BluetoothCharacteristic? _connectedCharacteristic;
//    String? _connectedDeviceName; // 新增：已连接设备名称
//     int? _batteryLevel; // 新增：电量数据
//      int? get batteryLevel => _batteryLevel;
//   // 获取已连接设备名称
//   String? get connectedDeviceName => _connectedDeviceName;
   
//   // 扫描到的设备列表
//   List<DeviceModels> devices = [];
//    // 连接成功事件回调
//   Function(BluetoothDevice)? onDeviceConnected;
// // 断开连接事件回调
//   Function(BluetoothDevice)? onDeviceDisconnected;
//  // 新增 UI 更新回调
//   Function()? onUIUpdate;
// //当前心率
//   int? _cuttentheartRate;
//   int? get heartRate => _cuttentheartRate;
//    List<int> _heartRateHistory = []; // 心率历史数据
//    List<int> get heartRateHistory => _heartRateHistory;
//    // 设置连接成功事件回调
//   void setOnDeviceConnected(Function(BluetoothDevice) callback) {
//     onDeviceConnected = callback;
  
//   }
//  // 设置断开连接事件回调
//   void setOnDeviceDisconnected(Function(BluetoothDevice) callback) {
//     onDeviceDisconnected = callback;
   
  

//   }
//   void setOnUIUpdate(Function() callback) {
//     onUIUpdate = callback;
//   }

//   // 开始扫描设备
//   Future<void> startScan(BuildContext context,{Duration? timeout}) async {
   
  
//    // print("开始扫描设备:");
//     FlutterBluePlus.startScan(timeout: timeout);

//    // 修改扫描监听逻辑
//     FlutterBluePlus.scanResults.listen((results) {
//       for (ScanResult result in results) {
//         final address = result.device.remoteId.str;
     
//         final existingIndex = devices.indexWhere((d) => d.address == address);
     
//         if (existingIndex == -1) {
//           // 新设备：创建并添加
//           devices.add(DeviceModels(
//             bluetoothDevice: result.device,
//             address: address,
//             name: result.device.platformName ?? 'Unknown',
//             rssi: result.rssi,
//             isConnected: false,
//             icon: '📱'
//           ));
//         } else {
//           // 已存在设备：更新信号强度
//           devices[existingIndex].rssi = result.rssi;
//         }
//       }
//            // 通知监听者更新
//       notifyListeners();
//     });





//   }

//  Future<bool> checkPermissions(BuildContext context) async {
//     // 定义需要请求的权限列表
//     Map<Permission, PermissionStatus> statuses = await [
//       Permission.bluetooth,
//       Permission.bluetoothScan,
//       Permission.bluetoothAdvertise,
//       Permission.bluetoothConnect,
//       Permission.notification,
//       Permission.location,
//        // Permission.photos,
//      // Permission.videos,
//       Permission.mediaLibrary, // 根据需要添加
//     ].request();

//     // 检查每个权限的状态
//     List<String> deniedPermissions = [];
//     for (var entry in statuses.entries) {
//       if (entry.value != PermissionStatus.granted) {
//         deniedPermissions.add(entry.key.toString());
//       }
//     }

//     if (deniedPermissions.isNotEmpty) {
//       // 显示权限拒绝提示
//       await showDialog(
//         context: context,
//         builder: (BuildContext context) {
//           return AlertDialog(
//             title: const Text('权限请求被拒绝'),
//             content: Text('以下权限被拒绝：\n${deniedPermissions.join('\n')}'),
//             actions: <Widget>[
//               TextButton(
//                 child: const Text('确定'),
//                 onPressed: () {
//                   Navigator.of(context).pop();
//                 },
//               ),
//             ],
//           );
//         },
//       );
//       return false;
//     }
//     return true;
//   }
//   // 停止扫描
//   Future<void> stopScan() async {
      
//           AppLogger.info('停止扫描设备');
//     FlutterBluePlus.stopScan();
//   }
//   ///清除未连接设备
// void clearUnconnectedDevices() {
//   AppLogger.info('清除未连接设备');
//   if (_connectedDevice != null) {
 
//     devices.removeWhere((device) => device.bluetoothDevice.remoteId.str != _connectedDevice?.remoteId.str);
//     AppLogger.info('清除未连接设备成功！');
//   } else{
//     AppLogger.error('清除未连接设备失败！');
//   }
//   notifyListeners();
// }

//    // 连接设备
//   Future<void> connectToDevice(BuildContext context, BluetoothDevice device) async {
//     try {
//       // 更新设备的 connectedType 为 connecting
//       final deviceModel = devices.firstWhere((d) => d.bluetoothDevice == device);
//       deviceModel.connectedType = ConnectedType.connecting;
//       notifyListeners();

//       await device.connect();
    
     

//       // 监听连接状态
//       device.connectionState.listen((state) async {
//         if (state == BluetoothConnectionState.connected) {
      
     
//           AppLogger.info('成功连接设备： ${device.platformName}');
//           _connectedDevice = device;
//            readBatteryLevel( device);
//           deviceModel.connectedType = ConnectedType.connected;
//           _connectedDeviceName = device.platformName; // 更新设备名称
         
//                 // 读取电量数据
//               await readBatteryLevel(device);
//               // 启动心率监听
//               _listenToHeartRate(device);

//           if (onDeviceConnected != null) {

//             onDeviceConnected!(device); // 触发连接成功事件
//             // 连接成功后清除未连接的设备
     
//           }    clearUnconnectedDevices();
//               notifyListeners(); // 通知监听者更新
//         } else if (state == BluetoothConnectionState.disconnected) {
   
//              AppLogger.info('设备已断开 ${device.platformName}');
//             deviceModel.connectedType = ConnectedType.disconnected;
          
//              await _cancelListenToHeartRate(device);
//            // 先触发断开回调，再清理资源
//             onDeviceDisconnected?.call(device);
//             _connectedDevice = null;
//             _connectedDeviceName = null;
//              notifyListeners(); // 通知监听者更新
       
//         } 
     
//         // 通知监听者更新
//         notifyListeners();
//       });

     

      
//     } catch (e,stack) {
//      final deviceModel = devices.firstWhere((d) => d.bluetoothDevice == device);
//       deviceModel.connectedType = ConnectedType.connectFailed;

//       // 通知监听者更新
//       notifyListeners();
//       AppLogger.error('连接设备时发生错误：$e',stack);
//       await showDialog(
//         context: context,
//         builder: (BuildContext context) {
         
//           return AlertDialog(
//             title: const Text('连接设备失败'),
//             content: Text('连接设备时发生错误：$e'),
//             actions: <Widget>[
//               TextButton(
//                 child: const Text('确定'),
//                 onPressed: () {
//                   deviceModel.connectedType = ConnectedType.unconnected;
//                   Navigator.of(context).pop();
//                    notifyListeners();
//                 },
//               ),
//             ],
//           );
//         },
//       );
//     }
//   }

//    // 断开连接
//   Future<void> disconnectDevice() async {
//     if (_connectedDevice != null) {
//       await _connectedDevice!.disconnect();
//         AppLogger.info('断开连接 ${_connectedDevice?.platformName}');
//       _connectedDevice = null;
//       _connectedService = null;
//       _connectedCharacteristic = null;
//        _connectedDeviceName = null; // 清除设备名称
  
   
//       // 更新设备的 connectedType 为 disconnected
//       final deviceModel = devices.firstWhere((d) => d.bluetoothDevice == _connectedDevice!);
//       deviceModel.connectedType = ConnectedType.disconnected;

//       // 通知监听者更新
//       notifyListeners();
//     }
//   }

//    // 设置当前服务和特征
//   void setConnectedServiceAndCharacteristic(
//       BluetoothService service, BluetoothCharacteristic characteristic) {
//     _connectedService = service;
//     _connectedCharacteristic = characteristic;
//     // 通知监听者更新
//     notifyListeners();
//   }

//    // 更新心率数据
//   void updateHeartRate(int heartRate) {
//     _cuttentheartRate=heartRate;
//     _heartRateHistory.add(heartRate); // 添加到历史数据
//     if (_heartRateHistory.length > 600) {
//       _heartRateHistory.removeAt(0); // 限制历史数据长度
//     }
//     notifyListeners(); // 通知监听者
//   }
// // 读取电量数据
//   Future<void> readBatteryLevel(BluetoothDevice device) async {
//     try {
//       // 查找电池服务
//       List<BluetoothService> services = await device.discoverServices();
//       for (BluetoothService service in services) {
//         if (service.uuid.toString() == "180f") {
//           // 查找电池特征
//           for (BluetoothCharacteristic characteristic in service.characteristics) {
//             if (characteristic.uuid.toString() == "2a19") {
//               // 读取电量数据
//               List<int> value = await characteristic.read();
//               if (value.isNotEmpty) {
//                 int batteryLevel = value[0]; // 电量数据
//                 // 更新设备的电量数据
//                 for (var deviceModel in devices) {
//                   if (deviceModel.bluetoothDevice == device) {
//                     deviceModel.batteryLevel = batteryLevel;
//                     _batteryLevel=batteryLevel;
              
//                       AppLogger.info("设备 ${deviceModel.name} 的电量为: $batteryLevel%");
              
//                     notifyListeners(); // 通知 UI 更新
//                     break;
//                   }
//                 }
//               }
//             }
//           }
//         }
//       }
//     } catch (e,stack) {
//       AppLogger.error("读取电量数据失败: $e",stack);
//      //print("读取电量数据失败: $e");
//     }
//   }
// /// 监听心率数据
// Future<void> _listenToHeartRate(BluetoothDevice device) async {
//   try {
   
//     // 发现服务
//     List<BluetoothService> services = await device.discoverServices();
//     for (BluetoothService service in services) {
//       // 找到心率服务
//       if (service.uuid.toString() == '180d') {
//         for (BluetoothCharacteristic characteristic in service.characteristics) {
//           // 找到心率测量特征
//           if (characteristic.uuid.toString() == '2a37') {
//             // 启用通知
//             await characteristic.setNotifyValue(true);

//               // 保存特征值引用
//             String key = device.remoteId.toString();
//             _characteristics[key] = characteristic;
//             // 监听心率数据
//             // 监听数据并保存订阅对象
//             _subscriptions[key] =characteristic.onValueReceived.listen((value) {
//               int heartRate = _parseHeartRate(value); // 解析心率数据
//               if (heartRate != -1) {
//                 // 更新心率数据
//                 updateHeartRate(heartRate);
//                 AppLogger.info('device:${device.platformName},hr: ${heartRate},BPM');
//                 //print('${device.platformName} 当前时间 : ${DateTime.now()}, 心率数据: $heartRate BPM');
//               }
//             });
//           }
//         }
//       }
//     }
//   } catch (e,stack) {
 
//        AppLogger.error("监听心率数据失败: $e",stack);
//   }
// }
// // 取消监听心率数据
// Future<void> _cancelListenToHeartRate(BluetoothDevice device) async {
//   String key = device.remoteId.toString();
  
//   // 取消订阅
//   if (_subscriptions.containsKey(key)) {
//     await _subscriptions[key]!.cancel();
//     _subscriptions.remove(key);
//   }

//   // 关闭通知
//   if (_characteristics.containsKey(key)) {
//     await _characteristics[key]!.setNotifyValue(false);
//     _characteristics.remove(key);
//   }
// AppLogger.info("已取消设备 ${device.platformName} 的监听");

// }
// int _parseHeartRate1(List<int> value) {
//   if (value.isNotEmpty) {
//     int flags = value[0];
//     if ((flags & 0x01) != 0) {
//       // 心率值是 16 位
//       return (value[1] << 8) | value[2];
//     } else {
//       // 心率值是 8 位
//       return value[1];
//     }
//   }
//   return -1; // 无效数据
// }

//       int _parseHeartRate(List<int> value) {
//            // 解析心率值
//                 int heartRate=0;
//                if (value.isNotEmpty) {
//                 // 解析心率数据
//                 int offset = 0;
//                 int flags = value[offset++]; // 读取标志位

              
//                 if ((flags & 0x01) == 0) {
//                   heartRate = value[offset++]; // UInt8
//                 } else {
//                   heartRate = (value[offset] << 8) | value[offset + 1]; // UInt16
//                   offset += 2;
//                 }

//                 // 解析能量消耗（可选）
//                 if ((flags & 0x08) != 0) {
//                   int energyExpended = (value[offset] << 8) | value[offset + 1]; // UInt16
//                   offset += 2;
              
//                   AppLogger.info("能量消耗: $energyExpended kJ");
//                    AppLogger.info('device:${_connectedDevice?.platformName},能量消耗: $energyExpended kJ');
//                 }

//                 // 解析 RR 间隔（可选）
//                 if ((flags & 0x10) != 0) {
//                   while (offset + 1 < value.length) {
//                     int rrInterval = (value[offset] << 8) | value[offset + 1]; // UInt16
//                     offset += 2;
//                      double rrIntervalSeconds = rrInterval / 1024.0; // 转换为秒
//                       //print("RR 间隔: $rrInterval (1/1024 秒), $rrIntervalSeconds 秒");
//                     AppLogger.info('device:${_connectedDevice?.platformName},RR 间隔: $rrInterval (1/1024 秒),$rrIntervalSeconds 秒');
//                   }
//                 }

               
//           }
//            return heartRate;
// }
//   // 获取已连接的设备
//   BluetoothDevice? get connectedDevice => _connectedDevice;

//   // 获取已连接的服务
//   BluetoothService? get connectedService => _connectedService;

//   // 获取已连接的特征
//   BluetoothCharacteristic? get connectedCharacteristic => _connectedCharacteristic;
// }
